The answer is: Yes.
gtk_widget_get_window
gtk_widget_register_window
gtk_widget_unregister_window
-gtk_cairo_should_draw_window
gtk_cairo_transform_to_window
gtk_widget_get_allocated_width
gtk_widget_get_allocated_height
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
GtkCalendarPrivate *priv = calendar->priv;
+ GtkStyleContext *context;
int i;
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (widget);
+ context = gtk_widget_get_style_context (widget);
- gtk_style_context_save (context);
- gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
+ gtk_style_context_save (context);
+ gtk_style_context_add_class (context, GTK_STYLE_CLASS_VIEW);
- gtk_render_background (context, cr, 0, 0,
- gtk_widget_get_allocated_width (widget),
- gtk_widget_get_allocated_height (widget));
- gtk_render_frame (context, cr, 0, 0,
- gtk_widget_get_allocated_width (widget),
- gtk_widget_get_allocated_height (widget));
+ gtk_render_background (context, cr, 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
+ gtk_render_frame (context, cr, 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
- gtk_style_context_restore (context);
- }
+ gtk_style_context_restore (context);
calendar_paint_main (calendar, cr);
GtkWidget *child,
cairo_t *cr)
{
- GdkWindow *child_in_window;
-
if (!_gtk_widget_is_drawable (child))
return FALSE;
- /* Never propagate to a child window when exposing a window
- * that is not the one the child widget is in.
- */
- if (_gtk_widget_get_has_window (child))
- child_in_window = gdk_window_get_parent (_gtk_widget_get_window (child));
- else
- child_in_window = _gtk_widget_get_window (child);
- if (!gtk_cairo_should_draw_window (cr, child_in_window))
- return FALSE;
-
return TRUE;
}
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
- if (!gtk_cairo_should_draw_window (cr, icon_view->priv->bin_window))
- return FALSE;
-
cairo_save (cr);
gtk_cairo_transform_to_window (cr, widget, icon_view->priv->bin_window);
int *natural_baseline);
static void gtk_layout_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
-static gint gtk_layout_draw (GtkWidget *widget,
- cairo_t *cr);
static void gtk_layout_add (GtkContainer *container,
GtkWidget *widget);
static void gtk_layout_remove (GtkContainer *container,
widget_class->map = gtk_layout_map;
widget_class->measure = gtk_layout_measure;
widget_class->size_allocate = gtk_layout_size_allocate;
- widget_class->draw = gtk_layout_draw;
container_class->add = gtk_layout_add;
container_class->remove = gtk_layout_remove;
gtk_layout_set_vadjustment_values (layout);
}
-static gboolean
-gtk_layout_draw (GtkWidget *widget,
- cairo_t *cr)
-{
- GtkLayout *layout = GTK_LAYOUT (widget);
- GtkLayoutPrivate *priv = layout->priv;
-
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- GTK_WIDGET_CLASS (gtk_layout_parent_class)->draw (widget, cr);
-
- return FALSE;
-}
-
/* Container methods
*/
static void
GtkMenuPrivate *priv;
GtkStyleContext *context;
GtkAllocation allocation;
+ int x, y;
menu = GTK_MENU (widget);
priv = menu->priv;
gtk_widget_get_allocation (widget, &allocation);
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
- {
- gtk_render_background (context, cr, 0, 0,
- allocation.width, allocation.height);
- gtk_render_frame (context, cr, 0, 0,
- allocation.width, allocation.height);
-
- if (priv->upper_arrow_visible)
- gtk_css_gadget_draw (priv->top_arrow_gadget, cr);
+ gtk_render_background (context, cr, 0, 0,
+ allocation.width, allocation.height);
+ gtk_render_frame (context, cr, 0, 0,
+ allocation.width, allocation.height);
- if (priv->lower_arrow_visible)
- gtk_css_gadget_draw (priv->bottom_arrow_gadget, cr);
- }
+ if (priv->upper_arrow_visible)
+ gtk_css_gadget_draw (priv->top_arrow_gadget, cr);
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- {
- int x, y;
+ if (priv->lower_arrow_visible)
+ gtk_css_gadget_draw (priv->bottom_arrow_gadget, cr);
- gdk_window_get_position (priv->view_window, &x, &y);
+ gdk_window_get_position (priv->view_window, &x, &y);
- cairo_rectangle (cr,
- x - allocation.x, y - allocation.y,
- gdk_window_get_width (priv->view_window),
- gdk_window_get_height (priv->view_window));
- cairo_clip (cr);
+ cairo_rectangle (cr,
+ x - allocation.x, y - allocation.y,
+ gdk_window_get_width (priv->view_window),
+ gdk_window_get_height (priv->view_window));
+ cairo_clip (cr);
- GTK_WIDGET_CLASS (gtk_menu_parent_class)->draw (widget, cr);
- }
+ GTK_WIDGET_CLASS (gtk_menu_parent_class)->draw (widget, cr);
return FALSE;
}
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkNotebookPrivate *priv = notebook->priv;
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
- gtk_css_gadget_draw (priv->gadget, cr);
+ gtk_css_gadget_draw (priv->gadget, cr);
- if (priv->operation == DRAG_OPERATION_REORDER &&
- gtk_cairo_should_draw_window (cr, priv->drag_window))
+ if (priv->operation == DRAG_OPERATION_REORDER)
gtk_css_gadget_draw (priv->cur_page->gadget, cr);
return FALSE;
int window_x, window_y;
gtk_widget_get_allocation (widget, &widget_allocation);
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)) &&
- priv->child1 && gtk_widget_get_visible (priv->child1) &&
+ if (priv->child1 && gtk_widget_get_visible (priv->child1) &&
priv->child2 && gtk_widget_get_visible (priv->child2))
gtk_css_gadget_draw (priv->handle_gadget, cr);
GtkAllocation *allocation);
static void gtk_revealer_real_map (GtkWidget *widget);
static void gtk_revealer_real_unmap (GtkWidget *widget);
-static gboolean gtk_revealer_real_draw (GtkWidget *widget,
- cairo_t *cr);
static void gtk_revealer_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
widget_class->size_allocate = gtk_revealer_real_size_allocate;
widget_class->map = gtk_revealer_real_map;
widget_class->unmap = gtk_revealer_real_unmap;
- widget_class->draw = gtk_revealer_real_draw;
widget_class->measure = gtk_revealer_measure;
container_class->add = gtk_revealer_real_add;
gtk_revealer_stop_animation (revealer);
}
-static gboolean
-gtk_revealer_real_draw (GtkWidget *widget,
- cairo_t *cr)
-{
- GtkRevealer *revealer = GTK_REVEALER (widget);
- GtkRevealerPrivate *priv = gtk_revealer_get_instance_private (revealer);
-
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- GTK_WIDGET_CLASS (gtk_revealer_parent_class)->draw (widget, cr);
-
- return GDK_EVENT_PROPAGATE;
-}
-
/**
* gtk_revealer_set_reveal_child:
* @revealer: a #GtkRevealer
GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
GtkScrolledWindowPrivate *priv = scrolled_window->priv;
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
- {
- if (priv->hscrollbar_visible &&
- priv->vscrollbar_visible)
- gtk_scrolled_window_draw_scrollbars_junction (scrolled_window, cr);
- }
+ if (priv->hscrollbar_visible &&
+ priv->vscrollbar_visible)
+ gtk_scrolled_window_draw_scrollbars_junction (scrolled_window, cr);
GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->draw (widget, cr);
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)))
- {
- gtk_scrolled_window_draw_undershoot (scrolled_window, cr);
- gtk_scrolled_window_draw_overshoot (scrolled_window, cr);
- }
+ gtk_scrolled_window_draw_undershoot (scrolled_window, cr);
+ gtk_scrolled_window_draw_overshoot (scrolled_window, cr);
return FALSE;
}
GtkStack *stack = GTK_STACK (widget);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
- if (priv->last_visible_surface &&
- gtk_cairo_should_draw_window (cr, priv->view_window))
+ if (priv->last_visible_surface)
{
GtkAllocation allocation;
int x, y;
cairo_restore (cr);
}
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- gtk_container_propagate_draw (GTK_CONTAINER (stack),
- priv->visible_child->widget,
- cr);
+ gtk_container_propagate_draw (GTK_CONTAINER (stack),
+ priv->visible_child->widget,
+ cr);
}
static gboolean
GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
GtkStack *stack = GTK_STACK (widget);
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
+ GtkStyleContext *context;
cairo_t *pattern_cr;
- if (gtk_cairo_should_draw_window (cr, priv->view_window))
- {
- GtkStyleContext *context;
-
- context = gtk_widget_get_style_context (widget);
- gtk_render_background (context,
- cr,
- 0, 0,
- gtk_widget_get_allocated_width (widget),
- gtk_widget_get_allocated_height (widget));
- }
+ context = gtk_widget_get_style_context (widget);
+ gtk_render_background (context,
+ cr,
+ 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
if (priv->visible_child)
{
switch (priv->active_transition_type)
{
case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- gtk_stack_draw_crossfade (widget, cr);
+ gtk_stack_draw_crossfade (widget, cr);
break;
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- gtk_stack_draw_under (widget, cr);
+ gtk_stack_draw_under (widget, cr);
break;
default:
g_assert_not_reached ();
}
}
- else if (gtk_cairo_should_draw_window (cr, priv->bin_window))
+ else
gtk_container_propagate_draw (GTK_CONTAINER (stack),
priv->visible_child->widget,
cr);
GtkStyleContext *context)
{
GdkWindow *window;
+ gint w, h;
+
if (text_window == NULL)
return;
window = gtk_text_view_get_window (text_view, text_window->type);
- if (gtk_cairo_should_draw_window (cr, window))
- {
- gint w, h;
+ w = gdk_window_get_width (window);
+ h = gdk_window_get_height (window);
- gtk_style_context_save_to_node (context, text_window->css_node);
+ gtk_style_context_save_to_node (context, text_window->css_node);
- w = gdk_window_get_width (window);
- h = gdk_window_get_height (window);
-
- cairo_save (cr);
- gtk_cairo_transform_to_window (cr, GTK_WIDGET (text_view), window);
- gtk_render_background (context, cr, 0, 0, w, h);
- cairo_restore (cr);
+ cairo_save (cr);
+ gtk_cairo_transform_to_window (cr, GTK_WIDGET (text_view), window);
+ gtk_render_background (context, cr, 0, 0, w, h);
+ cairo_restore (cr);
- gtk_style_context_restore (context);
- }
+ gtk_style_context_restore (context);
}
static gboolean
window = gtk_text_view_get_window (GTK_TEXT_VIEW (widget),
GTK_TEXT_WINDOW_TEXT);
- if (gtk_cairo_should_draw_window (cr, window))
- {
- DV(g_print (">Exposed ("G_STRLOC")\n"));
- cairo_save (cr);
- gtk_cairo_transform_to_window (cr, widget, window);
- draw_text (widget, cr);
- cairo_restore (cr);
- }
+ DV(g_print (">Exposed ("G_STRLOC")\n"));
+
+ cairo_save (cr);
+ gtk_cairo_transform_to_window (cr, widget, window);
+ draw_text (widget, cr);
+ cairo_restore (cr);
paint_border_window (GTK_TEXT_VIEW (widget), cr, priv->left_window, context);
paint_border_window (GTK_TEXT_VIEW (widget), cr, priv->right_window, context);
cairo_t *cr)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
- GtkWidget *button;
+ GtkWidget *button;
GtkStyleContext *context;
+ GList *list;
context = gtk_widget_get_style_context (widget);
- if (gtk_cairo_should_draw_window (cr, tree_view->priv->bin_window))
- {
- GList *tmp_list;
+ gtk_render_background (context, cr,
+ 0, 0,
+ gtk_widget_get_allocated_width (widget),
+ gtk_widget_get_allocated_height (widget));
- cairo_save (cr);
+ cairo_save (cr);
- gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
- gtk_tree_view_bin_draw (widget, cr);
+ gtk_cairo_transform_to_window (cr, widget, tree_view->priv->bin_window);
+ gtk_tree_view_bin_draw (widget, cr);
- cairo_restore (cr);
+ cairo_restore (cr);
- /* We can't just chain up to Container::draw as it will try to send the
- * event to the headers, so we handle propagating it to our children
- * (eg. widgets being edited) ourselves.
- */
- tmp_list = tree_view->priv->children;
- while (tmp_list)
- {
- GtkTreeViewChild *child = tmp_list->data;
- tmp_list = tmp_list->next;
+ /* We can't just chain up to Container::draw as it will try to send the
+ * event to the headers, so we handle propagating it to our children
+ * (eg. widgets being edited) ourselves.
+ */
+ for (list = tree_view->priv->children; list; list = list->next)
+ {
+ GtkTreeViewChild *child = list->data;
- gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
- }
+ gtk_container_propagate_draw (GTK_CONTAINER (tree_view), child->widget, cr);
}
- else if (tree_view->priv->drag_highlight_window &&
- gtk_cairo_should_draw_window (cr, tree_view->priv->drag_highlight_window))
+
+ if (tree_view->priv->drag_highlight_window)
{
GdkRGBA color;
}
cairo_restore (cr);
}
- else
- {
- gtk_render_background (context, cr,
- 0, 0,
- gtk_widget_get_allocated_width (widget),
- gtk_widget_get_allocated_height (widget));
- }
gtk_style_context_save (context);
gtk_style_context_remove_class (context, GTK_STYLE_CLASS_VIEW);
- if (gtk_cairo_should_draw_window (cr, tree_view->priv->header_window))
+ for (list = tree_view->priv->columns; list != NULL; list = list->next)
{
- GList *list;
-
- for (list = tree_view->priv->columns; list != NULL; list = list->next)
- {
- GtkTreeViewColumn *column = list->data;
+ GtkTreeViewColumn *column = list->data;
- if (column == tree_view->priv->drag_column)
- continue;
+ if (column == tree_view->priv->drag_column)
+ continue;
- if (gtk_tree_view_column_get_visible (column))
- {
- button = gtk_tree_view_column_get_button (column);
- gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
- button, cr);
- }
- }
+ if (gtk_tree_view_column_get_visible (column))
+ {
+ button = gtk_tree_view_column_get_button (column);
+ gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
+ button, cr);
+ }
}
-
- if (tree_view->priv->drag_window &&
- gtk_cairo_should_draw_window (cr, tree_view->priv->drag_window))
+
+ if (tree_view->priv->drag_window)
{
button = gtk_tree_view_column_get_button (tree_view->priv->drag_column);
gtk_container_propagate_draw (GTK_CONTAINER (tree_view),
gpointer data)
{
GtkWidget *widget = gtk_css_gadget_get_owner (gadget);
- GtkViewport *viewport = GTK_VIEWPORT (widget);
- GtkViewportPrivate *priv = viewport->priv;
- if (gtk_cairo_should_draw_window (cr, priv->bin_window))
- {
- GTK_WIDGET_CLASS (gtk_viewport_parent_class)->draw (widget, cr);
- }
+ GTK_WIDGET_CLASS (gtk_viewport_parent_class)->draw (widget, cr);
return FALSE;
}
GtkViewport *viewport = GTK_VIEWPORT (widget);
GtkViewportPrivate *priv = viewport->priv;
- if (gtk_cairo_should_draw_window (cr, gtk_widget_get_window (widget)) ||
- gtk_cairo_should_draw_window (cr, priv->bin_window))
- gtk_css_gadget_draw (priv->gadget, cr);
+ gtk_css_gadget_draw (priv->gadget, cr);
return FALSE;
}
return NULL;
}
-/**
- * gtk_cairo_should_draw_window:
- * @cr: a cairo context
- * @window: the window to check. @window may not be an input-only
- * window.
- *
- * This function is supposed to be called in #GtkWidget::draw
- * implementations for widgets that support multiple windows.
- * @cr must be untransformed from invoking of the draw function.
- * This function will return %TRUE if the contents of the given
- * @window are supposed to be drawn and %FALSE otherwise. Note
- * that when the drawing was not initiated by the windowing
- * system this function will return %TRUE for all windows, so
- * you need to draw the bottommost window first. Also, do not
- * use “else if” statements to check which window should be drawn.
- *
- * Returns: %TRUE if @window should be drawn
- *
- * Since: 3.0
- */
-gboolean
-gtk_cairo_should_draw_window (cairo_t *cr,
- GdkWindow *window)
-{
- GdkDrawingContext *context;
- GdkWindow *tmp;
-
- g_return_val_if_fail (cr != NULL, FALSE);
- g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);
-
- if (gtk_cairo_is_marked_for_draw (cr))
- return TRUE;
-
- context = gdk_cairo_get_drawing_context (cr);
- if (context == NULL)
- return TRUE;
-
- tmp = gdk_drawing_context_get_window (context);
- if (tmp == NULL)
- return TRUE;
-
- while (!gdk_window_has_native (window))
- window = gdk_window_get_parent (window);
-
- return tmp == window;
-}
-
typedef enum {
RENDER_SNAPSHOT,
RENDER_DRAW
GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_get_has_tooltip (GtkWidget *widget);
-GDK_AVAILABLE_IN_ALL
-gboolean gtk_cairo_should_draw_window (cairo_t *cr,
- GdkWindow *window);
GDK_AVAILABLE_IN_ALL
void gtk_cairo_transform_to_window (cairo_t *cr,
GtkWidget *widget,
layout = GTK_LAYOUT (widget);
bin_window = gtk_layout_get_bin_window (layout);
- if (!gtk_cairo_should_draw_window (cr, bin_window))
- return FALSE;
-
gdk_window_get_position (bin_window, &x, &y);
cairo_translate (cr, x, y);
projects / gtk4.git / commitdiff